通用命令模式：在多样化应用中实现操作类型安全

            
public enum DocumentActionType
{
    Create,
    Update,
    Delete
}

public class DocumentAction
{
    public DocumentActionType ActionType { get; set; }
    public string DocumentId { get; set; }
    public string Content { get; set; }
}

public interface ICommand<T>
{
    void Execute(T action);
}

public class CreateDocumentCommand : ICommand<DocumentAction>
{
    private readonly IDocumentService _documentService;

    public CreateDocumentCommand(IDocumentService documentService)
    {
        _documentService = documentService ?? throw new ArgumentNullException(nameof(documentService));
    }

    public void Execute(DocumentAction action)
    {
        if (action.ActionType != DocumentActionType.Create) throw new ArgumentException("Invalid action type for this command.");
        _documentService.CreateDocument(action.Content);
    }
}

public class UpdateDocumentCommand : ICommand<DocumentAction>
{
    private readonly IDocumentService _documentService;

    public UpdateDocumentCommand(IDocumentService documentService)
    {
        _documentService = documentService ?? throw new ArgumentNullException(nameof(documentService));
    }

    public void Execute(DocumentAction action)
    {
         if (action.ActionType != DocumentActionType.Update) throw new ArgumentException("Invalid action type for this command.");
        _documentService.UpdateDocument(action.DocumentId, action.Content);
    }
}

public interface IDocumentService
{
    void CreateDocument(string content);
    void UpdateDocument(string documentId, string content);
    void DeleteDocument(string documentId);
}

public class DocumentService : IDocumentService
{
    public void CreateDocument(string content)
    {
        Console.WriteLine($"Creating document with content: {content}");
    }

    public void UpdateDocument(string documentId, string content)
    {
        Console.WriteLine($"Updating document {documentId} with content: {content}");
    }

    public void DeleteDocument(string documentId)
    {
        Console.WriteLine($"Deleting document {documentId}");
    }
}

public class CommandInvoker
{
    private readonly Dictionary<DocumentActionType, Func<IDocumentService, ICommand<DocumentAction>>> _commands;
    private readonly IDocumentService _documentService;
    
    public CommandInvoker(IDocumentService documentService)
    {
        _documentService = documentService;
        _commands = new Dictionary<DocumentActionType, Func<IDocumentService, ICommand<DocumentAction>>>
        {
            { DocumentActionType.Create, service => new CreateDocumentCommand(service) },
            { DocumentActionType.Update, service => new UpdateDocumentCommand(service) },
            // Add Delete command similarly
        };
    }

    public void Invoke(DocumentAction action)
    {
        if (_commands.TryGetValue(action.ActionType, out var commandFactory))
        {
            var command = commandFactory(_documentService);
            command.Execute(action);
        }
        else
        {
            Console.WriteLine($"No command found for action type: {action.ActionType}");
        }
    }
}

// Usage
public class Example
{
    public static void Main(string[] args)
    {
        var documentService = new DocumentService();
        var invoker = new CommandInvoker(documentService);

        var createAction = new DocumentAction { ActionType = DocumentActionType.Create, Content = "Initial document content" };
        invoker.Invoke(createAction);

        var updateAction = new DocumentAction { ActionType = DocumentActionType.Update, DocumentId = "123", Content = "Updated content" };
        invoker.Invoke(updateAction);
    }
}

            

              
                Copy
              
            
          

            
public enum OrderActionType
{
    Create,
    Update,
    Cancel,
    Ship
}

public class OrderAction
{
    public OrderActionType ActionType { get; set; }
    public string OrderId { get; set; }
    public string CustomerId { get; set; }
    public List<OrderItem> OrderItems { get; set; }
    // Other order-related data
}

public class CreateOrderCommand : ICommand<OrderAction>
{
    private readonly IOrderService _orderService;

    public CreateOrderCommand(IOrderService orderService)
    {
        _orderService = orderService ?? throw new ArgumentNullException(nameof(orderService));
    }

    public void Execute(OrderAction action)
    {
         if (action.ActionType != OrderActionType.Create) throw new ArgumentException("Invalid action type for this command.");
        _orderService.CreateOrder(action.CustomerId, action.OrderItems);
    }
}

// Other command implementations (UpdateOrderCommand, CancelOrderCommand, ShipOrderCommand)

            

              
                Copy